This application claims priority of UK application No. 0002743.3 filed Feb. 7, 2000. That application is incorporated herein by reference.
The present invention relates generally to the field of communications and more specifically to a system and method for feature implementation and provisioning in a call processing environment.
Early forms of telephony systems of the prior art were mechanically driven using mechanical components. When a telephone call was placed using one of these early forms of telephony systems, few, if any features, were associated or available with the call. With advances in technology, not only the quality and efficiency of prior art systems improved, but also the capability of such systems to provide additional call features was enabled. This was primarily due to the evolution of traditional telephony systems from a mechanical architecture to an electronic architecture. With an electronic architecture, additional call features were facilitated in these prior art systems in hardware, firmware or software, usually under some form of processor or microprocessor based control. Thus the handling of a call, with its associated call features evolved into call processing.
More recent telephony system architectures, including Private Branch Exchanges (PBX), key systems, and telephony servers provide call processing to control and route the call, and provide the call features implemented within a code base embodied in the hardware, firmware, software, or some combination thereof.
Some call features are well known in the art, such as call block, call waiting, three-way calling, however new call features are continually being developed and implemented by telephony system developers and manufacturers.
Introducing new features into a typical prior art call processing environment requires numerous changes distributed throughout the code base. These changes are necessary to address different aspects of the features, such as the user interface, feature validation, feature activation, feature interaction and state specific behaviours.
Interactions between features can be complicated and are often handled specifically in the code base where the feature is implemented. Additional code base changes must be introduced to the code base to manage specific interactions, as required to deal with each possible combination of feature interaction. The code base then becomes the only accurate record of how feature interactions are handled.
Over time, changes to the code base causes the code base to become increasingly destabilized as more and more features are added and modified.
One prior art method of introducing new features into call processing, while limiting changes to the code base, uses feature hooks. This method de-couples the feature implementation and interactions from the code base. The provisioning of features in this prior art method is controlled by binding feature hooks in the code base to the associated feature code or by flags (e.g. Feature-Allowed-Night-Services). However, this prior art method still requires changes to the code base to handle new features (inserting appropriate feature hooks). Interactions between features also require specialized feature hooks or changes to the code base. Making changes to the code base itself requires the telephony system to be shut down, is time consuming, and can be destabilizing if not properly implemented.
A second prior art method uses the Advanced Intelligent Networking (AIN) model. The code base is programmed to signal interested features when an event occurs and allows the features to respond as required. Features that act on the same signal may negotiate as peers or submit to arbitration. In this prior art method feature interactions are handled without requiring changes to the code base. Drawbacks of this model include the performance impact associated with signaling of interested features, and non-deterministic event handling with inconsistent outcomes.
A further prior art method is set forth in Aspect-Oriented Programming by Gregor Kiczales, John Lamping, Anurag Mendhekar, Chris Maeda, Cristina Videira Lopes, Jean-Marc Loingtier and John Irwin in Proceedings of the European Conference on Object-Oriented Programming (ECOOP), Finland, Springer-Verlag LNCS 1241, June 1997, which, at the time of this specification, was available at http://www.parc.xerox.com/cs1/groups/sda/publications/papers/Kiczales-ECOOP97/. An aspect is defined with respect to a system and general purpose language, as a property that must be implemented and xe2x80x9ccannot be cleanly encapsulated in a generalized procedurexe2x80x9d. In Aspect-Oriented programming, each aspect is identified and coded as a separate program. These programs are distinct from regular general-purpose language component programs. A specialized compiler referred to as an xe2x80x9caspect weaverxe2x80x9d, accepts aspect programs and regular components as input and generates an implementation that integrates them together. This fusion of code results in an executable that is different from the implementation in the sense that when a developer reviews the executable for the purpose of rouble shooting, it is not recognizable from the original program. However, in this method, the ability to maintain the system is compromised and new risks due to the exposure to the new type of compiler are also introduced.
There is a requirement in the art for a stable, efficient and effective system and method of call processing feature implementation and provisioning where features may be introduced, changed or removed without destabilizing the code base.
The present invention is directed to providing a stable, efficient and effective system and method of implementing and provisioning features and thereby providing feature services in a call processing environment where features may be introduced, changed or removed without destabilizing the code base. In the inventive system and method, features are fully implemented outside the code base. Features are introduced or xe2x80x9cinjectedxe2x80x9d into the call processing environment using a feature registry. The feature registry is used to manage feature configuration, behavior and interactions. The code base references the feature registry to apply features during operation. In this manner, features can be implemented by reference without modification or rebuilding of the code base. Features can be added, modified or removed without requiring a system upgrade, even while the code base is in operation. The code base uses a structured framework into which features can be introduced by reference using the feature registry. A feature service manager exclusively controls the feature registry and handles provisioning of features. Feature interaction potential is identified and resolved during feature provisioning. The feature service manager can be configured to enforce feature integrity and behaviour rules specific to the call processing product being provisioned.
Therefore, according to one aspect of the present invention there is provided a system for providing call features in a call processing environment comprising: (a) a code base; (b) a feature registry connected to the code base for describing features; and (c) a feature service manager, coupled to the feature registry for managing the feature registry, wherein the features are introduced for application by code base by reference.
Also, according to another aspect of the present invention there is provided a method for providing call features in a call processing environment comprising the steps of: (a) creating a structured framework for describing call features; (b) instrumenting a code base according to the framework; (c) establishing a feature registry for storing instances of the features corresponding to the framework, separately connected to said code base; and (d) creating a feature service manager, coupled to the feature registry for managing the feature registry, wherein the instances of the features managed by the feature service manager are implemented by the code base by reference to the feature registry.